web/src/services/gql/provider/links/langLink.ts (1)

5-13: Add TypeScript types for better type safety.

Consider adding explicit type definitions for the context and headers:

+  interface Headers {
+    [key: string]: string;
+  }
+
+  interface Context {
+    headers?: Headers;
+  }

-  return setContext(async (_, { headers }) => {
+  return setContext(async (_, { headers }: Context) => {

web/src/sentry.ts (1)

15-26: Improve type checking in error handling.

While the array-based error reporting looks good, the type checking could be enhanced:

1. The instanceof Error check might not catch all error types since error is of type ReportError
2. The type definition suggests error should have type and message properties

Consider this implementation:

 export const reportError = (errors: ReportError[]) => {
   errors.forEach((error) => {
-    if (error instanceof Error) {
+    if (error instanceof Error || error.constructor?.name === 'Error') {
       Sentry.captureException(error);
     } else {
       Sentry.captureException(
         new Error(
           `${error.type || "Unknown"}: ${error.message || "No message provided"}`
         )
       );
     }
   });
 };

web/src/services/gql/provider/links/errorLink.ts (1)

14-16: Improve null-safety in network error handling.

The optional chaining on networkError?.message is redundant in the array initialization since it's already checked in the condition.

 if (networkError?.message) {
   errors = [
-    { message: networkError?.message, description: networkError.message }
+    { message: networkError.message, description: networkError.message }
   ];

web/src/beta/features/Notification/hooks.ts (3)

26-26: Consider adding explicit type annotations for better type safety.

While the code works, adding explicit type annotations would improve type safety and code documentation.

-  const [errors, setErrors] = useErrors();
+  const [errors, setErrors] = useErrors<Array<{ message?: string; description?: string }>>();

---

54-55: Consider deduplicating error messages.

When processing multiple errors, consider deduplicating similar messages to prevent notification spam.

-    errors.forEach((error) => {
+    const uniqueErrors = errors.filter((error, index, self) =>
+      index === self.findIndex(e => e.message === error.message)
+    );
+    uniqueErrors.forEach((error) => {

---

70-82: Consider prioritizing error notifications.

The current implementation shows all errors sequentially. Consider prioritizing critical errors or grouping similar errors.

+      const errorPriority = error.message?.includes("policy violation") ? 1 : 2;
+      const notification = {
+        priority: errorPriority,
         type: error.message?.includes("policy violation") ? "info" : "error",
         heading: error.message?.includes("policy violation") ? noticeHeading : errorHeading,
         text: error.message?.includes("policy violation") ? message : (error.description || error.message || ""),
         ...(error.message?.includes("policy violation") && { duration: "persistent" })
+      };

Configuration used: .coderabbit.yaml
Review profile: CHILL
Plan: Pro